package br.edu.unipampa.clube;

import br.edu.unipampa.campeonato.MercadoDeTransferencias;

/**
 * @author Antoni, Gean, Vinicius
 * matricula 121150124,121151418, 121151385
 * @version 1.1
 * @since 8/03/13
 */
public class Tecnico{
    
    private String nome;                               //Nome do tecnico                     
    private Clube clubeQueDirige;                      //Clube que ele dirige
   
    /**
     * Método construtor que já inicializa os atributos da classe
     * @param nome, do tipo String
     */
    public Tecnico(String nome){
        this.nome = nome;
        this.clubeQueDirige = null;
    }
    
    /**
     * Método que consulta os jogadores presentes no mercado de transferencia
     * ou seja, os jogadores disponiveis para a compra
     * 
     * @param mercado, do tipo MercadoDeTransferencias
     */
    public void consultarMercado(MercadoDeTransferencias mercado){
        for (int i = 0; i < mercado.getJogadoresDisponiveis().size(); i++) {
            System.out.println(mercado.getJogadoresDisponiveis().get(i).getNome());
        }
     }
    
    /**
     * Método que compra jogadores do mercado de transferencias e adiciona no clube do
     * usuario. Para a realizaçao da compra testa-se se o clube tem dinheiro suficiente,
     * se existe o jogador especifico no mercado e se existe "espaço" para o jogador na 
     * equipe, já que cada equipe tem um limite de 19 jogadores em seu elenco
     * 
     * @param mercado, do tipo MercadoDeTransferencias
     * @param nomeDoJogador, do tipo String
     * @return true/false, do tipo boolean
     */
    public boolean comprarJogador(MercadoDeTransferencias mercado, String nomeDoJogador){
         for (int i = 0; i < mercado.getJogadoresDisponiveis().size(); i++) {
             if (mercado.getJogadoresDisponiveis().get(i).getNome().equalsIgnoreCase(nomeDoJogador)) {
               if(clubeQueDirige.getDinheiroEmCaixa() >= mercado.getJogadoresDisponiveis().get(i).getPreco()){
                   if(clubeQueDirige.getVagas() >= 1){
                      clubeQueDirige.setDinheiroEmCaixa(clubeQueDirige.getDinheiroEmCaixa() - mercado.getJogadoresDisponiveis().get(i).getPreco());
                      clubeQueDirige.addListaDeJogadores(mercado.getJogadoresDisponiveis().get(i));
                      clubeQueDirige.setVagas(clubeQueDirige.getVagas()-1);
                      System.out.println("\nTransição realizada com sucesso!");
                      System.out.println("\nDinheiro em caixa do clube: R$ "+clubeQueDirige.getDinheiroEmCaixa());
                      return true;     
                   }else{
                       System.out.println("É impossivel comprar mais jogadores, seu elenco está completo!\nPara que seja possível realizar uma"
                               + "compra, venda algum jogador reserva!");
                       return false;
                   }
                 }else{
                   System.out.println("O clube não tem dinheiro suficiente para pagar o salario do jogador");
                   return false;
                }
              } 
            }
        System.out.println("Jogador inexistente ou não está a venda!");
        return false;
    }
    
    /**
     * Método que vende jogadores do clube, para um outro clube, esses passados
     * como parametros do método. Para isso, testa-se se esse jogador existe no
     * clube, se o clube a ser vendido nao é o mesmo clube que o jogador já estava
     * e se o clube para onde o jogador será vendido realmente existe.
     * 
     * @param nomeDoJogador, do tipo String
     * @param clubeNovo, do tipo Clube
     * @return true/false, do tipo boolean
     */
    public boolean venderJogador(String nomeDoJogador, Clube clubeNovo){
        for (int i = 0; i < clubeQueDirige.getListaDeJogadores().size(); i++) {
            if(clubeQueDirige.getListaDeJogadores().get(i).getNome().equalsIgnoreCase(nomeDoJogador)){
                if(clubeNovo != clubeQueDirige) {
                    if(clubeQueDirige.getVagas() <= 8){
                       Jogador captura = clubeQueDirige.getListaDeJogadores().get(i);
                       clubeQueDirige.getListaDeJogadores().remove(captura);
                       clubeNovo.addListaDeJogadores(captura);
                       clubeQueDirige.setDinheiroEmCaixa(clubeQueDirige.getDinheiroEmCaixa() + clubeQueDirige.getListaDeJogadores().get(i).getPreco());
                       clubeQueDirige.setVagas(clubeQueDirige.getVagas()+1);
                       System.out.println("\nTransição realizada com sucesso!");
                       System.out.println("\nDinheiro em caixa do clube: R$ "+clubeQueDirige.getDinheiroEmCaixa());
                       return true;     
                    }else{
                        System.out.println("Você nao pode vender mais jogadores! \nPara realizar essa operação, você deve ter mais "
                                + "jogadores em seu elenco!");
                    }
                  }else{
                    System.out.println("Você nao pode vender o jogador para o clube que ele já pertence!");   
                   return false;
                }
            }
        }
        System.out.println("O jogador que você quer vender nao existe ou nao esta em seu clube");
        return false;
    }
    
    //Método que consulta jogadores do clube 
    public void consultarJogadoresDoClube(){
         for (int i = 0; i < clubeQueDirige.getListaDeJogadores().size(); i++) {
            System.out.println(clubeQueDirige.getListaDeJogadores().get(i).getNome()+" ***** Posição: "+clubeQueDirige.getListaDeJogadores().get(i).getPosicao());
        }       
    }

    /**
     * Método sobrecarregado, que consulta jogadores de um clube específico
     * mais precisamente, de um clube rival
     * 
     * @param clube, do tipo Clube
     */
    public void consultarJogadoresDoClube(Clube clube){
        System.out.println("************************************** Clube: "+clube.getNome()+" **************************************");
        for (int i = 0; i < clube.getListaDeJogadores().size(); i++) {
            System.out.println(clube.getListaDeJogadores().get(i).getNome()+" ---- Posição: "
                    +clube.getListaDeJogadores().get(i).getPosicao()+" -----  Força: "
                    +clube.getListaDeJogadores().get(i).getForca());
        }
         System.out.println("******************************************************************************************************");
    }
   
    /*
     * Método que mostra o time, exibe o conjunto de jogadores
     * titulares e reservas
     */
    public void escalarTime(){
        System.out.println("************ Time Titular ************");
        for (int i = 0; i < clubeQueDirige.getListaDeTitulares().size(); i++) {
            System.out.println(i+" - "+clubeQueDirige.getListaDeTitulares().get(i).getNome()
                    +" - Posição: "+clubeQueDirige.getListaDeTitulares().get(i).getPosicao()
                    +" - Força: "+clubeQueDirige.getListaDeTitulares().get(i).getForca());
        }
        System.out.println("\n************ Time Reserva ************");
        for (int i = 0; i < clubeQueDirige.getListaDeReservas().size(); i++) {
            System.out.println(i+" - "+clubeQueDirige.getListaDeReservas().get(i).getNome()
                    +" - Posição: "+clubeQueDirige.getListaDeReservas().get(i).getPosicao()
                    +" - Força: "+clubeQueDirige.getListaDeReservas().get(i).getForca());
        }
    }
    
    /**
     * Método que substitui jogadores do time, nele sao passados como
     * parametros, os codigos dos dois jogadores que se quer substituir
     * respectivamente, titular e reserva
     * 
     * @param numTitular, do tipo int
     * @param numReserva, do tipo int
     */
    public void substituirNaEscalacao(int numTitular, int numReserva){
        Jogador jogadorTimeTitular = clubeQueDirige.getListaDeTitulares().get(numTitular);
        Jogador jogadorTimeReserva = clubeQueDirige.getListaDeReservas().get(numReserva);
        
        clubeQueDirige.getListaDeTitulares().remove(numTitular);
        clubeQueDirige.getListaDeReservas().remove(numReserva);
        
        clubeQueDirige.getListaDeTitulares().add(numTitular, jogadorTimeReserva);
        clubeQueDirige.getListaDeReservas().add(numReserva, jogadorTimeTitular);
        System.out.println("----------------- Foi Substituido o jogador '"+jogadorTimeTitular.getNome()
                +"' pelo jogador '"+jogadorTimeReserva.getNome()+"' -----------------");
    }
    
    /**
     * Método que altera os jogadores que estão em campo,
     * ou seja, a substituição durante a partida de futebol.
     * Este método foi criado para alterar os jogadores apenas
     * durante a partida, sem modificar a lista de jogadores titulares ou reservas.
     */
    public void definirSubstituicao(){
        System.out.println("************ Time em Campo ************");
        for (int i = 0; i < clubeQueDirige.getListaDeJogadoresTitularesDaPartida().size(); i++) {
            System.out.println(i+" - "+clubeQueDirige.getListaDeJogadoresTitularesDaPartida().get(i).getNome()
                    +" - Posição: "+clubeQueDirige.getListaDeJogadoresTitularesDaPartida().get(i).getPosicao()
                    +" - Força: "+clubeQueDirige.getListaDeJogadoresTitularesDaPartida().get(i).getForca());
        }
        System.out.println("\n************ Time Reserva ************");
        for (int i = 0; i < clubeQueDirige.getListaDeJogadoresReservaDaPartida().size(); i++) {
            System.out.println(i+" - "+clubeQueDirige.getListaDeJogadoresReservaDaPartida().get(i).getNome()
                    +" - Posição: "+clubeQueDirige.getListaDeJogadoresReservaDaPartida().get(i).getPosicao()
                    +" - Força: "+clubeQueDirige.getListaDeJogadoresReservaDaPartida().get(i).getForca());
        }
    }
    /**
     * Método que troca um jogador da lista de titulares por 
     * um jogador da lista de reservas, definidos pelo usuário...
     * Este método remove o jogador da lista de titulares e adiciona-o
     * a lista de reservas, e remove um jogador da lista de reservas e
     * adiciona-o a lista de titulares, exatamente em suas posiçoes 
     * pré estabelecidas
     * @param numTitular
     * @param numReserva 
     */
    public void substituicaoNoTime(int numTitular, int numReserva){
        Jogador jogadorTimeTitular = clubeQueDirige.getListaDeTitulares().get(numTitular);
        Jogador jogadorTimeReserva = clubeQueDirige.getListaDeReservas().get(numReserva);
        
        clubeQueDirige.getListaDeJogadoresTitularesDaPartida().remove(numTitular);
        clubeQueDirige.getListaDeJogadoresReservaDaPartida().remove(numReserva);
        
        clubeQueDirige.getListaDeJogadoresTitularesDaPartida().add(numTitular, jogadorTimeReserva);
        clubeQueDirige.getListaDeReservas().add(numReserva, jogadorTimeTitular);
        System.out.println("----------------- Foi Substituido o jogador '"+jogadorTimeTitular.getNome()
                +"' pelo jogador '"+jogadorTimeReserva.getNome()+"' -----------------");
    }

    public Clube getClubeQueDirige() {
        return clubeQueDirige;
    }

    public void setClubeQueDirige(Clube clubeQueDirige) {
        this.clubeQueDirige = clubeQueDirige;
    }
}
